package com.zyg.cart.service.impl;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.zyg.cart.client.ManagerClient;
import com.zyg.cart.enttiy.ItemEntity;
import com.zyg.cart.enttiy.TbOrderItem;
import com.zyg.cart.enttiy.group.Cart;
import com.zyg.cart.service.CartService;
import com.zyg.common.utils.IdWorker;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * ------------------------------
 * 作者: LMY
 * 类-功能: XX
 * 创建时间: 2021-11-15 18:48
 * ------------------------------
 **/
@Service
public class CartServiceImpl implements CartService {

    //引入Redis
    @Autowired
    private StringRedisTemplate redisTemplate;

    //引入Manager远程调用接口
    @Autowired
    private ManagerClient managerClient;

    //idWorker
    @Autowired
    private IdWorker idWorker;

    /**
     * 作者 : LMY
     * 功能 : 添加商品到购物车
     * 时间 : 2021/11/15 22:37
     *结构
     *用户登录名:{商家id：''
     *          商家名称：‘’
     *          该商家购物项的集合：list
     *      }
     * 1、拿到用户的id
     * 2、根据SKU商品id查出SKU商品对象
     * 2、拿到商家的名称与id
     */
    @Override
    public void addCart(String name, Long itemId, int num) {
        //1. 根据id查出SKU商品对象
        ItemEntity itemEntity = managerClient.findById(itemId);

        if(itemEntity == null){
            System.out.println("没有此商品 id:" + itemId);
            return ;
        }

        //2. 从Redis取出购物车集合
        String carts = redisTemplate.opsForValue().get(name);
        //3. 定义一个购物车集合
        List<Cart> cartList = null;
        //4. 判断是否为空
        if(StrUtil.isBlank(carts)){ //如果为空,给个初始值
           cartList = new ArrayList<>();
        }else {                     //不为空,转换为集合，
            cartList = JSON.parseArray(carts,Cart.class);
        }

        //5.找出是否由同一商家的购物车存在
        Cart cart = findByCart(cartList,itemEntity.getSellerId());

        //6. 判断该购物车是否为空
        if(cart == null){  //证明没有该购物车
            //6.1 创建一个Cart
            cart = createCart(itemEntity,num);
            //6.2 添加到用户对应的购物车集合
            cartList.add(cart);
        }else {     //有该购物车，将这个商品添加进去，
            //6.3 取出这个商品项集合
            List<TbOrderItem> orderItemList = cart.getOrderItemList();
            //6.4 遍历集合和这个商品相同的商品项
            TbOrderItem orderItem = findByOrderItem(orderItemList,itemEntity);
            //6.5 非空判断,
            if(orderItem == null){  //集合里面没有这个商品项
                //创建一个商品项目
                orderItem = crateOrderItem(itemEntity, num);
                //添加到购物车
                cart.getOrderItemList().add(orderItem);
            }else {                 //集合中有这个商品项，修改数量和小计
                //重新计算数量
                orderItem.setNum(orderItem.getNum() + num);
                //重新计算小计
                orderItem.setTotalFee(new BigDecimal(orderItem.getNum() * orderItem.getPrice().doubleValue()));
            }

            //极端情况处理：
            //① 如果某个商品项的数量为0，删除整个商品项
            if(orderItem.getNum() <= 0){
                cart.getOrderItemList().remove(orderItem);
            }
            //② 如果购物车空了，删除整个购物车
            if(cart.getOrderItemList().size() == 0){
                cartList.remove(cart);
            }
        }
        //以用户为key,购物车集合为值，存入Redis
        redisTemplate.opsForValue().set(name,JSON.toJSONString(cartList),30, TimeUnit.DAYS);
        System.out.println("添加商品到，购物车成功咯!");
    }


    /**
     * 作者 : LMY
     * 功能 : 判断是否有同一商家的购物车，如果有则返回Cart 没有则返回空
     * 时间 : 2021/11/15 20:04
     */
    private Cart findByCart(List<Cart> cartList, String sellerId) {
        if(cartList != null && cartList.size() > 0){
            //1. 遍历购物车
            for (Cart cart : cartList) {
                if(sellerId.equals(cart.getSellerId())){
                    return cart;
                }
            }
        }
        return null;
    }

    /**
     * 作者 : LMY
     * 功能 : 创建购物车
     * Cart ：{
     *     sellerId：‘’
     *     sellerName:''
     *    list<orderItem> orderItems
     *  }
     *
     * 时间 : 2021/11/15 20:09
     */
    private Cart createCart(ItemEntity itemEntity, int num) {
        //1. 定义一个集合
        List<TbOrderItem> orderItems = new ArrayList<>();
        Cart cart = new Cart();
        //2. 创建一个商品项对象
        TbOrderItem orderItem = crateOrderItem(itemEntity,num);
        //3. 添加商品项到集合
        orderItems.add(orderItem);
        cart.setSellerId(itemEntity.getSellerId());
        cart.setSellerName(itemEntity.getSeller());
        cart.setOrderItemList(orderItems);
        //4. 封装Cart对象并返回
        return  cart;
    }

    private TbOrderItem crateOrderItem(ItemEntity itemEntity,int num) {
        TbOrderItem orderItem = new TbOrderItem();

        //3. 生成一个随机id
        long id = idWorker.nextId();
        //4. 封装  orderItem 对象的属性
        orderItem.setId(id);
        orderItem.setTitle(itemEntity.getTitle());
        orderItem.setPicPath(itemEntity.getImage());
        orderItem.setGoodsId(itemEntity.getGoodsId());  //SPU商品id
        orderItem.setItemId(itemEntity.getId());        //SKU商品id
        orderItem.setNum(num);                          //商品数量
        orderItem.setPrice(itemEntity.getPrice());       //商品单价
        orderItem.setTotalFee(new BigDecimal(num * itemEntity.getPrice().doubleValue())); //小计

        return orderItem;
    }


    /**
     * 作者 : LMY
     * 功能 : 查询是否相同的商品项
     * 时间 : 2021/11/15 21:00
     */
    private TbOrderItem findByOrderItem(List<TbOrderItem> orderItemList, ItemEntity itemEntity) {
        //1. 遍历商品项集合
        for (TbOrderItem orderItem : orderItemList) {
            if(orderItem.getItemId().longValue() == itemEntity.getId().longValue()){
                return orderItem;
            }
        }
        return null;
    }


    /**
     * 作者 : LMY
     * 功能 : 根据用户名，拿到用户的购物车
     * 时间 : 2021/11/16 16:55
     */
    @Override
    public List<Cart> getCartList(String name) {
        //1. 根据用户名从Redis中取出对应的购物车
        String cart = redisTemplate.opsForValue().get(name);
        //2. 判断是否有值
        if(StrUtil.isNotBlank(cart)){
            //将JSON字符串转换为list集合
            List<Cart> cartList = JSON.parseArray(cart,Cart.class);
            //返回集合
            return cartList;
        }
        //3. 如果Redis中没有，返回一个空集合
        return new ArrayList<>();
    }




}
